#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Gate.io交易所下单示例
"""

import asyncio
import logging
import os
import sys
from pathlib import Path
from sqlalchemy import select

# 添加项目根目录到Python路径
project_root = Path(__file__).parent.parent
sys.path.insert(0, str(project_root))

from services.exchange.adapters.gate_adapter import GateAdapter
from services.exchange.interface import ExchangeType
from models.user_api_key import UserApiKey
from models.base import get_db_session
from services.contract_config_adapter import format_price
from services.strategies.base import StrategyBase

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

async def get_gate_api_credentials(user_id=None, exchange="gate"):
    """
    从数据库获取Gate.io API凭证
    
    参数:
        user_id: 用户ID，如果不指定则获取第一个符合条件的API密钥
        exchange: 交易所名称，默认为"gate"
        
    返回:
        包含api_key和api_secret的字典，如果没有找到则返回None
    """
    # 使用项目中定义的数据库会话
    session = get_db_session()
    
    try:
        # 构建查询
        query = select(UserApiKey).where(UserApiKey.exchange == exchange)
        if user_id:
            query = query.where(UserApiKey.user_id == user_id)
        
        # 执行查询
        api_key_record = session.execute(query).scalar_one_or_none()
        
        if api_key_record:
            logger.info(f"找到用户 {api_key_record.user_id} 的 {exchange} API密钥")
            # 直接使用UserApiKey模型中的get_credentials方法
            return api_key_record.get_credentials()
        else:
            logger.error(f"未找到 {exchange} API密钥")
            return None
            
    except Exception as e:
        logger.error(f"获取API密钥时发生错误: {e}")
        return None
    finally:
        session.close()

async def place_order_example():
    """下单示例"""
    # 从数据库获取API密钥
    credentials = await get_gate_api_credentials()
    
    if not credentials:
        logger.error("未能从数据库获取有效的API密钥，请确保已在user_api_keys表中设置了Gate.io的API密钥")
        return
    
    # 创建Gate交易所适配器实例
    # 默认使用正式环境，如果需要使用测试网，请设置use_testnet=True
    gate = GateAdapter(
        api_key=credentials["api_key"],
        api_secret=credentials["api_secret"],
    )
    
    try:
        # 获取BTC_USDT的最新行情
        symbol = "ETH-USDT"
        ticker = await gate.get_ticker(symbol)
        current_price = float(ticker['last'])
        logger.info(f"{symbol}最新价格: {current_price}")
        
        # 格式化价格（比当前价格低5%）
        order_price = str(format_price(ExchangeType.GATE, symbol, current_price))
        logger.info(f"格式化后的下单价格: {order_price}")
        
        # 设置交易参数
        margin = 1  # 保证金金额（USDT）
        leverage = 25.0  # 杠杆倍数
        
        # 创建一个临时的策略实例来计算仓位大小
        temp_strategy = StrategyBase(symbol=symbol)
        size = temp_strategy.calculate_position_size(
            margin=margin,
            leverage=leverage,
            price=current_price
        )
        
        logger.info(f"计算的仓位大小: {size}张合约 (保证金: {margin} USDT, 杠杆: {leverage}倍)")
        # 下买单示例（限价单）
        # 参数说明：
        # symbol: 交易对
        # size: 订单数量，正数为买入，负数为卖出
        # price: 订单价格
        # side: 订单方向，"buy"或"sell"
        # order_type: 订单类型，"limit"或"market"
        # tif: 订单时效性，"gtc"(一直有效直至取消)
        # text: 订单自定义信息，例如"t-my-custom-id"
        order = await gate.create_order(
            symbol=symbol,
            price=0,
            side="buy",
            size=size,  # 使用计算得到的仓位大小
            text="t-example-order"
        )
        
        logger.info(f"下单成功: {order}")
        logger.info(f"订单ID: {order['id']}")
        logger.info(f"订单状态: {order['status']}")
        
        # order = await gate.create_order(
        #     symbol=symbol,
        #     price=0,
        #     side="sell",
        #     size=0,  # 使用计算得到的仓位大小
        #     text="t-example-order",
        #     auto_size="close_short",
        #     reduce_only=True
        # )
        # logger.info(f"下单成功: {order}")
        
        # logger.info(f"下单成功: {order}")
        # logger.info(f"订单ID: {order['id']}")
        # logger.info(f"订单状态: {order['status']}")
        
    except Exception as e:
        logger.error(f"发生错误: {e}")
    finally:
        # 关闭连接
        await gate.close()

if __name__ == "__main__":
    # 运行示例
    asyncio.run(place_order_example()) 